home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / deleteln.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  7.9 KB  |  304 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    deleteln
  25. #undef    wdeleteln
  26. #undef    insdelln
  27. #undef    winsdelln
  28. #undef    insertln
  29. #undef    winsertln
  30.  
  31. /* undefine any macros for functions called by this module if in debug mode */
  32. #ifdef PDCDEBUG
  33. #endif
  34.  
  35. #ifdef PDCDEBUG
  36. char *rcsid_deleteln  = "$Id$";
  37. #endif
  38.  
  39. /*man-start*********************************************************************
  40.  
  41.   Name:                                                      deleteln
  42.  
  43.   Synopsis:
  44.       int deleteln(void);
  45.       int wdeleteln(WINDOW *win);
  46.       int insdelln(int n);
  47.       int winsdelln(WINDOW *win, int n);
  48.       int insertln(void);
  49.       int winsertln(WINDOW *win);
  50.  
  51.   X/Open Description:
  52.      With the deleteln() and wdelteln() functions,
  53.      the line under the cursor in the window is deleted.  All
  54.      lines below the current line are moved up one line.  The
  55.      bottom line of the window is cleared.  The cursor position
  56.      does not change.
  57.  
  58.      With the insertln() and winsertn() functions,
  59.      a blank line is inserted above the current line and the bottom
  60.      line is lost.
  61.  
  62.      NOTE: deleteln() and insertln() are implemented as macros.
  63.  
  64.   X/Open Return Value:
  65.      All functions return OK on success and ERR on error.
  66.  
  67.   X/Open Errors:
  68.      No errors are defined for this function.
  69.  
  70.   NOTE:
  71.      The behaviour of Unix curses is to clear the line with a space
  72.      and attributes of A_NORMAL. PDCurses clears the line with the
  73.      window's current attributes (including current colour). To get
  74.      the behaviour of PDCurses, #define PDCURSES_WCLR in curses.h or
  75.      add -DPDCURSES_WCLR to the compile switches.
  76.  
  77.   Portability                             X/Open    BSD    SYS V
  78.                                           Dec '88
  79.       deleteln                              Y        Y       Y
  80.       wdeleteln                             Y        Y       Y
  81.       insdelln                              -        -      4.0
  82.       winsdelln                             -        -      4.0
  83.       insertln                              Y        Y       Y
  84.       winsertln                             Y        Y       Y
  85.  
  86. **man-end**********************************************************************/
  87.  
  88. /***********************************************************************/
  89. int    deleteln(void)
  90. /***********************************************************************/
  91. {
  92.     chtype    blank;
  93.     chtype*    end;
  94.     chtype*    temp;
  95.     chtype*    ptr;
  96.     int    y;
  97.  
  98. #ifdef PDCDEBUG
  99.     if (trace_on) PDC_debug("deleteln() - called\n");
  100. #endif
  101.  
  102.     if (stdscr == (WINDOW *)NULL)
  103.         return( ERR );
  104.  
  105. #if defined(PDCURSES_WCLR)
  106.     blank    = stdscr->_blank | stdscr->_attrs;
  107. #else
  108. /* wrs (4/10/93) account for window background */
  109.     blank    = stdscr->_bkgd;
  110. #endif
  111.     temp    = stdscr->_y[stdscr->_cury];
  112.  
  113.     for (y = stdscr->_cury; y < stdscr->_bmarg; y++)
  114.     {
  115.         stdscr->_y[y]     = stdscr->_y[y + 1];
  116.         stdscr->_firstch[y] = 0;
  117.         stdscr->_lastch[y] = stdscr->_maxx - 1;
  118.     }
  119.  
  120.     for (ptr = temp; (ptr - temp < stdscr->_maxx); ptr++)
  121.         *ptr = blank;            /* make a blank line */
  122.  
  123.     if( stdscr->_cury <= stdscr->_bmarg ) 
  124.     {
  125.         stdscr->_firstch[stdscr->_bmarg]    = 0;
  126.         stdscr->_lastch[stdscr->_bmarg]    = stdscr->_maxx - 1;
  127.         stdscr->_y[stdscr->_bmarg]        = temp;
  128.     }
  129.  
  130.     return( OK );
  131. }
  132. /***********************************************************************/
  133. int    wdeleteln(WINDOW *win)
  134. /***********************************************************************/
  135. {
  136.     chtype    blank;
  137.     chtype*    end;
  138.     chtype*    temp;
  139.     chtype*    ptr;
  140.     int    y;
  141.  
  142. #ifdef PDCDEBUG
  143.     if (trace_on) PDC_debug("wdeleteln() - called\n");
  144. #endif
  145.  
  146.     if (win == (WINDOW *)NULL)
  147.         return( ERR );
  148.  
  149. #if defined(PDCURSES_WCLR)
  150.     blank    = win->_blank | win->_attrs;
  151. #else
  152. /* wrs (4/10/93) account for window background */
  153.     blank    = win->_bkgd;
  154. #endif
  155.     temp    = win->_y[win->_cury];
  156.  
  157.     for (y = win->_cury; y < win->_bmarg; y++)
  158.     {
  159.         win->_y[y]     = win->_y[y + 1];
  160.         win->_firstch[y] = 0;
  161.         win->_lastch[y] = win->_maxx - 1;
  162.     }
  163.  
  164.     for (ptr = temp; (ptr - temp < win->_maxx); ptr++)
  165.         *ptr = blank;            /* make a blank line */
  166.  
  167.     if( win->_cury <= win->_bmarg ) 
  168.     {
  169.         win->_firstch[win->_bmarg]    = 0;
  170.         win->_lastch[win->_bmarg]    = win->_maxx - 1;
  171.         win->_y[win->_bmarg]        = temp;
  172.     }
  173.  
  174.     return( OK );
  175. }
  176. /***********************************************************************/
  177. int    insdelln(int n)
  178. /***********************************************************************/
  179. {
  180. #ifdef PDCDEBUG
  181.     if (trace_on) PDC_debug("insdelln() - called\n");
  182. #endif
  183.  
  184.     if (stdscr == (WINDOW *)NULL)
  185.         return( ERR );
  186.  
  187.     return(winsdelln(stdscr,n));
  188. }
  189. /***********************************************************************/
  190. int    winsdelln(WINDOW *win, int n)
  191. /***********************************************************************/
  192. {
  193.     int i;
  194.  
  195. #ifdef PDCDEBUG
  196.     if (trace_on) PDC_debug("winsdelln() - called\n");
  197. #endif
  198.  
  199.     if (win == (WINDOW *)NULL)
  200.         return( ERR );
  201.  
  202.     if( n > 0 ) {
  203.         for(i=0; i<n; i++) {
  204.             if( winsertln(win) == ERR )
  205.                 return ERR;
  206.         }
  207.     }
  208.     else if( n < 0 ) {
  209.         n = -n;
  210.         for(i=0; i<n; i++) {
  211.             if( wdeleteln(win) == ERR )
  212.                 return ERR;
  213.         }
  214.     }
  215.  
  216.     return( OK );
  217. }
  218. /***********************************************************************/
  219. int    insertln(void)
  220. /***********************************************************************/
  221. {
  222.     chtype    blank;
  223.     chtype*    temp;
  224.     chtype*    end;
  225.     short    y;
  226.  
  227. #ifdef PDCDEBUG
  228.     if (trace_on) PDC_debug("insertln() - called\n");
  229. #endif
  230.  
  231.     if (stdscr == (WINDOW *)NULL)
  232.         return( ERR );
  233.  
  234. #if defined(PDCURSES_WCLR)
  235.     blank    = stdscr->_blank | stdscr->_attrs;
  236. #else
  237. /* wrs (4/10/93) account for window background */
  238.     blank    = stdscr->_bkgd;
  239. #endif
  240.     temp    = stdscr->_y[stdscr->_maxy-1];
  241.  
  242.     for (y = stdscr->_maxy-1; y > stdscr->_cury; y--)
  243.     {
  244.         stdscr->_y[y]     = stdscr->_y[y - 1];
  245.         stdscr->_firstch[y] = 0;
  246.         stdscr->_lastch[y] = stdscr->_maxx - 1;
  247.     }
  248.  
  249.     stdscr->_y[stdscr->_cury] = temp;
  250.  
  251.     for (end = &temp[stdscr->_maxx - 1]; temp <= end; temp++)
  252.     {
  253.         *temp = blank;
  254.     }
  255.  
  256.     stdscr->_firstch[stdscr->_cury] = 0;
  257.     stdscr->_lastch[stdscr->_cury] = stdscr->_maxx - 1;
  258.  
  259.     return( OK );
  260. }
  261. /***********************************************************************/
  262. int    winsertln(WINDOW *win)
  263. /***********************************************************************/
  264. {
  265.     chtype    blank;
  266.     chtype*    temp;
  267.     chtype*    end;
  268.     short    y;
  269.  
  270. #ifdef PDCDEBUG
  271.     if (trace_on) PDC_debug("winsertln() - called\n");
  272. #endif
  273.  
  274.     if (win == (WINDOW *)NULL)
  275.         return( ERR );
  276.  
  277. #if defined(PDCURSES_WCLR)
  278.     blank    = win->_blank | win->_attrs;
  279. #else
  280. /* wrs (4/10/93) account for window background */
  281.     blank    = win->_bkgd;
  282. #endif
  283.     temp    = win->_y[win->_maxy-1];
  284.  
  285.     for (y = win->_maxy-1; y > win->_cury; y--)
  286.     {
  287.         win->_y[y]     = win->_y[y - 1];
  288.         win->_firstch[y] = 0;
  289.         win->_lastch[y] = win->_maxx - 1;
  290.     }
  291.  
  292.     win->_y[win->_cury] = temp;
  293.  
  294.     for (end = &temp[win->_maxx - 1]; temp <= end; temp++)
  295.     {
  296.         *temp = blank;
  297.     }
  298.  
  299.     win->_firstch[win->_cury] = 0;
  300.     win->_lastch[win->_cury] = win->_maxx - 1;
  301.  
  302.     return( OK );
  303. }
  304.